package com.lupan.tomcatStudy.javaStudy.chapter6.innerClass;

/**
 * @author lupan
 * @version 2016/4/14 0014
 */
public class Cow  {

    //静态(类)初始化块，类加载时运行，先于构造器
    static {
        className = "Cow";
        //不能访问实例属性
        //weight = 0.1;
    }

    //动态（实例）初始化块，创建实例时运行，先于构造器
    {
        className = "Cow";
        weight = 110.5;
    }

    private double weight;
    private String color = "黑白";
    private static String className = "牛";

    public void info(){
        //外部内不能直接访问非静态内部类信息，只能创建实例后访问
        CowLeg cowLeg = new CowLeg();
        System.out.println();
    }

    /**
     * 非静态内部类
     */
    private class CowLeg{

        private double length=1.2;
        private String color="黑色";
        //非静态内部类不能定义静态成员，方法
        //private static String className;

        public void info(){
            System.out.println( this.toString() );
        }

        public String toString(){
            //非静态内部类可以直接访问外部类属性
            return String.format("我是牛腿，长度：%s，颜色：%s，我的主人牛，重量%s，颜色%s，类名%s",
                    this.length,this.color,Cow.this.weight,Cow.this.color,Cow.className);
        }
    }

    /**
     * 静态内部类
     */
    private static class CowLegStatic{

        private double length=1.2;
        private String color="黑色";
        //静态内部类可以定义静态成员，方法
        private static String className = "静态牛腿";

        public void info(){
            System.out.println( this.toString() );
        }

        public String toString(){
            //内部类可以直接访问外部类静态属性，不能访问非静态属性
            return String.format("我是静态牛腿，长度：%s，颜色：%s，我的主人牛，类名：%s",
                    this.length,this.color,Cow.className);
        }
    }


    public static void main(String[] args){

        //非静态内部类的外部调用
        CowLeg cowLeg = new Cow().new CowLeg();
        cowLeg.info();

        //静态内部类的外部调用
        CowLegStatic cowLegStatic = new CowLegStatic();
        cowLegStatic.info();

        //局部内部类,作用域是方法内，不能有修饰符
        class PartInnerClass{
            public int a = 0;
            //不能有静态属性
            //public static int b = 0;
        }
        System.out.println(new PartInnerClass().a);

        //匿名内部类，创建只使用一次的类
        final int n = 0;
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("内部线程运行！"+n);
            }
        });
    }

}
